Una clase es un objeto, una función es un objeto, un método de una clase es un objeto... Todo es un objeto. Todo tiene atributos y métodos que consultar o ejecutar.
Esto permite crear clases, funciones o métodos de manera imperativa con class o def y también pueden declararse por asignación.
En python se puede trabajar usando, a la vez, los tres paradigmas: imperativo, orientado a objetos y funcional. Conviene empezar por el que más se conoce e ir ampliando funcionalidad a los otros métodos.
Se puede crear una clase como un prototipo (como en javascript), o de forma declarativa (como en C++).
>>> class Declarativa():
... atributo=32
... def __init__(self,name):
... self.name=name
... self.subs = []
... def __str__(self):
... return "{}: {}".format(self.name, ", ".join(self.subs))
...
>>> a = Declarativa("hola")
>>> print(a)
hola:
>>> a.subs.append("aa")
>>> a.subs.append("bb")
>>> print(a)
hola: aa, bb>>> class Declarativa():
... atributo=32
... def __init__(self,name):
... self.name=name
... self.subs = []
... def __str__(self):
... return "{}: {}".format(self.name, ", ".join(self.subs))
...
>>> a = Declarativa("hola")
>>> print(a)
hola:
>>> a.subs.append("aa")
>>> a.subs.append("bb")
>>> print(a)
hola: aa, bbPrototipo
# primero se declaran los métodos
>>> def proto__init__(self, name):
... self.name = name
... self.subs = []
...
>>> def proto__str__(self):
... return "{}: {}".format(self.name, ", ".join(self.subs))
>>> Prototipo = type("Prototipo", (object,), {
... "__init__": proto__init__,
... "__str__": proto__str__,
... "atributo_de_clase": 32})
# también se puede añadir un método después por separado
>>> def mostrar(self):
... print(self)
...
>>> Prototipo.mostrar = mostrar
>>> p = Prototipo("proto")
>>> p.mostrar()
proto:
>>> p.subs.append("pp")
>>> p.subs.append("qq")
>>> p.mostrar()
proto: pp, qq# primero se declaran los métodos
>>> def proto__init__(self, name):
... self.name = name
... self.subs = []
...
>>> def proto__str__(self):
... return "{}: {}".format(self.name, ", ".join(self.subs))
>>> Prototipo = type("Prototipo", (object,), {
... "__init__": proto__init__,
... "__str__": proto__str__,
... "atributo_de_clase": 32})
# también se puede añadir un método después por separado
>>> def mostrar(self):
... print(self)
...
>>> Prototipo.mostrar = mostrar
>>> p = Prototipo("proto")
>>> p.mostrar()
proto:
>>> p.subs.append("pp")
>>> p.subs.append("qq")
>>> p.mostrar()
proto: pp, qqLa ventaja es que se puede modificar y extender una clase por códig, tantas veces como deseemos.
Tuplas con nombre A veces necesitamos una pequeña clase, sin perder mucho tiempo en escribirla, en ese caso usaremos las tuplas con nombre que es parecido a las clases por prototipos
>>> from collections import namedtuple
>>> Punto = namedtuple('Punto', ['x','y'])
>>> p1 = Punto(4, 2)>>> from collections import namedtuple
>>> Punto = namedtuple('Punto', ['x','y'])
>>> p1 = Punto(4, 2)La ventaja es que se crea enseguida y se usa con los métodos de una tupla.